Dominando el Contexto de Aplicación y la Gestión del Contexto de Solicitud de Flask para Aplicaciones Globales

En el dinámico mundo del desarrollo web, especialmente al construir aplicaciones para una audiencia global, comprender los mecanismos subyacentes que rigen su framework es primordial. Flask, un framework web Python ligero y flexible, ofrece herramientas potentes para administrar el estado de la aplicación y los datos específicos de la solicitud. Entre estos, el Contexto de Aplicación y el Contexto de Solicitud son conceptos fundamentales que, cuando se entienden y utilizan correctamente, pueden conducir a aplicaciones más robustas, escalables y mantenibles. Esta guía completa desmitificará estos contextos, explorando su propósito, cómo funcionan y cómo aprovecharlos eficazmente para aplicaciones web globales.

Comprendiendo los Conceptos Centrales: Contextos en Flask

Antes de profundizar en los detalles del contexto de aplicación y de solicitud, establezcamos una comprensión fundamental de lo que significa 'contexto' en este escenario. En Flask, un contexto es una forma de hacer que ciertos objetos, como la solicitud actual o la propia aplicación, sean fácilmente accesibles dentro de su código, particularmente cuando no está directamente dentro de una función de vista.

La Necesidad de Contextos

Imagine que está construyendo una aplicación Flask que sirve a usuarios en diferentes continentes. Una sola solicitud podría implicar:

• Acceder a configuraciones de toda la aplicación (por ejemplo, credenciales de base de datos, claves API).
• Recuperar información específica del usuario (por ejemplo, preferencias de idioma, datos de sesión).
• Realizar operaciones únicas para esa solicitud específica (por ejemplo, registrar detalles de la solicitud, manejar envíos de formularios).

Sin una forma estructurada de gestionar estas variadas piezas de información, su código se volvería desordenado y difícil de razonar. Los contextos proporcionan esta estructura. Flask usa proxies para lograr esto. Los proxies son objetos que delegan sus operaciones a otro objeto, que se determina en tiempo de ejecución. Los dos proxies principales en Flask son current_app y g (para el contexto de solicitud), y el propio current_app también puede representar el contexto de la aplicación.

Contexto de Aplicación de Flask

El Contexto de Aplicación es un objeto que almacena datos específicos de la aplicación que están disponibles durante toda la vida útil de la solicitud de una aplicación. Es esencialmente un contenedor para información a nivel de aplicación que necesita ser accesible globalmente dentro de su aplicación Flask, pero también necesita ser distinto para cada instancia de aplicación en ejecución (especialmente en implementaciones de múltiples aplicaciones).

Qué Gestiona:

El Contexto de Aplicación gestiona principalmente:

• Instancia de la Aplicación: La instancia actual de la aplicación Flask en sí. Se accede a esto a través del proxy current_app.
• Configuración: La configuración de la aplicación (por ejemplo, desde app.config).
• Extensiones: Información relacionada con las extensiones de Flask integradas con la aplicación.

Cómo Funciona:

Flask empuja automáticamente un contexto de aplicación cuando:

• Se está procesando una solicitud.
• Usa el decorador @app.appcontext o el bloque with app.app_context():.

Cuando un contexto de aplicación está activo, el proxy current_app apuntará a la instancia correcta de la aplicación Flask. Esto es crucial para aplicaciones que pueden tener múltiples aplicaciones Flask ejecutándose o cuando necesita acceder a recursos a nivel de aplicación desde fuera de un manejador de solicitud típico (por ejemplo, en tareas en segundo plano, comandos CLI o pruebas).

Empujando el Contexto de Aplicación Manualmente:

En ciertos escenarios, es posible que necesite empujar explícitamente un contexto de aplicación. Esto es común cuando se trabaja con Flask fuera de un ciclo de solicitud, como en interfaces de línea de comandos personalizadas (CLI) o durante las pruebas. Puede lograr esto utilizando el método app.app_context(), normalmente dentro de una declaración with:

            from flask import Flask, current_app

app = Flask(__name__)
app.config['MY_SETTING'] = 'Global Value'

# Fuera de una solicitud, necesita empujar el contexto para usar current_app
with app.app_context():
    print(current_app.config['MY_SETTING']) # Output: Global Value

# Ejemplo en un comando CLI (usando Flask-CLI)
@app.cli.command('show-setting')
def show_setting_command():
    with app.app_context():
        print(f"My setting is: {current_app.config['MY_SETTING']}")

            

              
                Copy
              
            
          

Esta gestión explícita del contexto asegura que current_app siempre esté vinculado a la instancia de aplicación correcta, evitando errores y proporcionando acceso a los recursos de toda la aplicación.

Aplicaciones Globales y Contexto de Aplicación:

Para aplicaciones globales, el contexto de la aplicación es vital para gestionar recursos y configuraciones compartidas. Por ejemplo, si su aplicación necesita cargar diferentes conjuntos de datos de internacionalización (i18n) o localización (l10n) basados en el idioma de la solicitud, el proxy current_app puede acceder a la configuración que apunta a estos recursos. Aunque el contexto de solicitud contendrá el idioma específico del usuario, el current_app es la puerta de entrada para acceder a la configuración general de i18n de la aplicación.

Contexto de Solicitud de Flask

El Contexto de Solicitud es más transitorio que el contexto de la aplicación. Se crea y destruye para cada solicitud entrante a su aplicación Flask. Contiene datos que son específicos de la solicitud HTTP actual y es crucial para manejar las interacciones individuales de los usuarios.

Qué Gestiona:

El Contexto de Solicitud gestiona principalmente:

• Objeto de Solicitud: La solicitud HTTP entrante, accesible a través del proxy request.
• Objeto de Respuesta: La respuesta HTTP saliente.
• Sesión: Datos de sesión del usuario, accesibles a través del proxy session.
• Datos Globales (g): Un objeto especial, g, que se puede usar para almacenar datos arbitrarios durante una sola solicitud. Esto se usa a menudo para almacenar conexiones a bases de datos, objetos de usuario u otros objetos específicos de la solicitud a los que necesitan acceder múltiples partes de su aplicación durante esa solicitud.

Cómo Funciona:

Flask empuja automáticamente un contexto de solicitud cada vez que se está procesando una solicitud HTTP entrante. Este contexto se empuja encima de el contexto de la aplicación. Esto significa que dentro de un manejador de solicitud, tanto current_app como request (y g, session) están disponibles.

Cuando la solicitud termina de procesarse (ya sea devolviendo una respuesta o generando una excepción), Flask saca el contexto de la solicitud. Esta limpieza asegura que los recursos asociados con esa solicitud específica sean liberados.

Accediendo a Datos Específicos de la Solicitud:

Aquí hay un ejemplo típico dentro de una función de vista:

            
from flask import Flask, request, g, session, current_app

app = Flask(__name__)
app.secret_key = 'your secret key'

@app.route('/')
def index():
    # Accediendo a datos de la solicitud
    user_agent = request.headers.get('User-Agent')
    user_ip = request.remote_addr

    # Accediendo a datos de la aplicación a través de current_app
    app_name = current_app.name

    # Almacenando datos en g para esta solicitud
    g.request_id = 'some-unique-id-123'

    # Estableciendo datos de sesión (requiere secret_key)
    session['username'] = 'global_user_example'

    return f"¡Hola! Tu IP es {user_ip}, User Agent: {user_agent}. Aplicación: {app_name}. ID de solicitud: {g.request_id}. Usuario de sesión: {session.get('username')}"

@app.route('/profile')
def profile():
    # Accediendo a datos de g establecidos en otra vista durante el mismo ciclo de solicitud
    # Nota: Esto solo es posible si la ruta /profile se accedió a través de una redirección o un reenvío interno
    #       desde la ruta '/' dentro de la misma solicitud. En la práctica, es mejor
    #       pasar los datos explícitamente o usar la sesión.
    request_id_from_g = getattr(g, 'request_id', 'No establecido')
    return f"Página de perfil. ID de solicitud (desde g): {request_id_from_g}"

            

              
                Copy
              
            
          

En este ejemplo, request, g, session y current_app son todos accesibles porque Flask ha empujado automáticamente los contextos de aplicación y solicitud.

Empujando el Contexto de Solicitud Manualmente:

Si bien Flask generalmente maneja el empuje del contexto de solicitud automáticamente durante las solicitudes HTTP, hay situaciones en las que es posible que necesite simular un contexto de solicitud para pruebas o procesamiento en segundo plano. Puede hacerlo utilizando app.request_context(). Esto se usa a menudo junto con app.app_context().

            
from flask import Flask, request, current_app

app = Flask(__name__)
app.config['MY_SETTING'] = 'Global Value'

# Simular un contexto de solicitud
with app.test_request_context('/test', method='GET', headers={'User-Agent': 'TestClient'}):
    print(request.method) # Output: GET
    print(request.headers.get('User-Agent')) # Output: TestClient
    print(current_app.name) # Output: __main__ (or your app's name)

    # Incluso puedes usar g dentro de este contexto simulado
    g.test_data = 'Some test info'
    print(g.test_data) # Output: Some test info

            

              
                Copy
              
            
          

El método test_request_context es una forma conveniente de crear un entorno de solicitud simulada para sus pruebas, lo que le permite verificar cómo se comporta su código en diferentes condiciones de solicitud sin necesidad de un servidor en vivo.

La Relación entre el Contexto de Aplicación y el Contexto de Solicitud

Es crucial comprender que estos contextos no son independientes; forman una pila.

• El Contexto de Aplicación es la base: Se empuja primero y permanece activo mientras la aplicación se está ejecutando o hasta que se saca explícitamente.
• El Contexto de Solicitud está en la parte superior: Se empuja después del contexto de la aplicación y está activo solo durante la duración de una sola solicitud.

Cuando llega una solicitud, Flask hace lo siguiente:

1. Empuja el Contexto de Aplicación: Si no hay un contexto de aplicación activo, empuja uno. Esto asegura que current_app esté disponible.
2. Empuja el Contexto de Solicitud: Luego empuja el contexto de solicitud, haciendo que request, g y session estén disponibles.

Cuando la solicitud se completa:

1. Saca el Contexto de Solicitud: Flask elimina el contexto de solicitud.
2. Saca el Contexto de Aplicación: Si ninguna otra parte de su aplicación tiene una referencia a un contexto de aplicación activo, también podría sacarse. Sin embargo, normalmente, el contexto de la aplicación persiste mientras el proceso de la aplicación está activo.

Esta naturaleza apilada es la razón por la que current_app siempre está disponible cuando request está disponible, pero request no está necesariamente disponible cuando current_app lo está (por ejemplo, cuando solo empuja manualmente un contexto de aplicación).

Gestionando Contextos en Aplicaciones Globales

Construir aplicaciones para una audiencia global diversa presenta desafíos únicos. La gestión del contexto juega un papel fundamental en la resolución de estos:

1. Internacionalización (i18n) y Localización (l10n):

Desafío: Los usuarios de diferentes países hablan diferentes idiomas y tienen diferentes expectativas culturales (por ejemplo, formatos de fecha, símbolos de moneda). Su aplicación necesita adaptarse.

Solución de Contexto:

• Contexto de Aplicación: El current_app puede contener la configuración para su configuración i18n (por ejemplo, idiomas disponibles, rutas de archivos de traducción). Esta configuración está disponible globalmente para la aplicación.
• Contexto de Solicitud: El objeto request se puede usar para determinar el idioma preferido del usuario (por ejemplo, desde el encabezado Accept-Language, la ruta de la URL o el perfil del usuario almacenado en la sesión). El objeto g se puede usar luego para almacenar la configuración regional determinada para la solicitud actual, lo que la hace fácilmente accesible para todas las partes de la lógica de su vista y plantillas.

Ejemplo (usando Flask-Babel):

            
from flask import Flask, request, g, current_app
from flask_babel import Babel, get_locale

app = Flask(__name__)
app.config['BABEL_DEFAULT_LOCALE'] = 'en'
app.config['BABEL_DEFAULT_TIMEZONE'] = 'UTC'

babel = Babel(app)

# El contexto de la aplicación se empuja implícitamente por Flask-Babel durante la inicialización
# y estará disponible durante las solicitudes.

@babel.localeselector
def get_locale():
    # Intente obtener el idioma de la URL primero (por ejemplo, /en/about)
    if 'lang' in request.view_args:
        g.current_lang = request.view_args['lang']
        return request.view_args['lang']

    # Intente obtener el idioma de los encabezados del navegador del usuario
    user_lang = request.accept_languages.best_match(app.config['LANGUAGES'])
    if user_lang:
        g.current_lang = user_lang
        return user_lang

    # Retroceda al valor predeterminado de la aplicación
    g.current_lang = app.config['BABEL_DEFAULT_LOCALE']
    return app.config['BABEL_DEFAULT_LOCALE']

@app.route('//hello')
def hello_lang(lang):
    # current_app.config['BABEL_DEFAULT_LOCALE'] es accesible
    # g.current_lang fue establecido por get_locale()
    return f"¡Hola en {g.current_lang}!"

@app.route('/hello')
def hello_default():
    # get_locale() se llamará automáticamente
    return f"¡Hola en {get_locale()}!"

            

              
                Copy
              
            
          

Aquí, current_app proporciona acceso a la configuración regional predeterminada, mientras que request y g se utilizan para determinar y almacenar la configuración regional específica para la solicitud del usuario actual.

2. Zonas Horarias y Manejo de Fecha/Hora:

Desafío: Diferentes usuarios están en diferentes zonas horarias. Almacenar y mostrar marcas de tiempo debe ser preciso y relevante para el usuario.

Solución de Contexto:

• Contexto de Aplicación: El current_app puede contener la zona horaria predeterminada del servidor o una zona horaria base para todas las marcas de tiempo almacenadas en la base de datos.
• Contexto de Solicitud: El objeto request (o datos derivados del perfil/sesión del usuario) puede determinar la zona horaria local del usuario. Esta zona horaria se puede almacenar en g para facilitar el acceso al formatear fechas y horas para su visualización dentro de esa solicitud específica.

Ejemplo:

            
from flask import Flask, request, g, current_app
from datetime import datetime
import pytz # Una biblioteca de zonas horarias robusta

app = Flask(__name__)
app.config['SERVER_TIMEZONE'] = 'UTC'

# Función para obtener la zona horaria del usuario (simulada)
def get_user_timezone(user_id):
    # En una aplicación real, esto consultaría una base de datos o sesión
    timezones = {'user1': 'America/New_York', 'user2': 'Asia/Tokyo'}
    return timezones.get(user_id, app.config['SERVER_TIMEZONE'])

@app.before_request
def set_timezone():
    # Simular un usuario conectado
    user_id = 'user1'
    g.user_timezone_str = get_user_timezone(user_id)
    g.user_timezone = pytz.timezone(g.user_timezone_str)

@app.route('/time')
def show_time():
    now_utc = datetime.now(pytz.utc)
    # Formatear la hora para la zona horaria del usuario actual
    now_user_tz = now_utc.astimezone(g.user_timezone)
    formatted_time = now_user_tz.strftime('%Y-%m-%d %H:%M:%S %Z%z')

    # Accediendo a la zona horaria base de la aplicación
    server_tz_str = current_app.config['SERVER_TIMEZONE']

    return f"Hora actual en tu zona horaria ({g.user_timezone_str}): {formatted_time}

              El servidor está configurado en: {server_tz_str}"

            

              
                Copy
              
            
          

Esto demuestra cómo g puede contener datos específicos de la solicitud, como la zona horaria del usuario, lo que lo hace fácilmente disponible para el formato de tiempo, mientras que current_app contiene la configuración global de la zona horaria del servidor.

3. Moneda y Procesamiento de Pagos:

Desafío: Mostrar precios y procesar pagos en diferentes monedas es complejo.

Solución de Contexto:

• Contexto de Aplicación: current_app puede almacenar la moneda base de la aplicación, las monedas admitidas y el acceso a los servicios o la configuración de conversión de moneda.
• Contexto de Solicitud: El request (o la sesión/perfil del usuario) determina la moneda preferida del usuario. Esto se puede almacenar en g. Al mostrar los precios, recupera el precio base (a menudo almacenado en una moneda consistente) y lo convierte utilizando la moneda preferida del usuario, que está fácilmente disponible a través de g.

4. Conexiones y Recursos de la Base de Datos:

Desafío: Gestionar eficientemente las conexiones a la base de datos para muchas solicitudes concurrentes. Es posible que diferentes usuarios necesiten conectarse a diferentes bases de datos según su región o tipo de cuenta.

Solución de Contexto:

• Contexto de Aplicación: Puede gestionar un grupo de conexiones a la base de datos o la configuración para conectarse a diferentes instancias de la base de datos.
• Contexto de Solicitud: El objeto g es ideal para contener la conexión específica a la base de datos que se utilizará para la solicitud actual. Esto evita la sobrecarga de establecer una nueva conexión para cada operación dentro de una sola solicitud y garantiza que las operaciones de la base de datos para una solicitud no interfieran con otra.

Ejemplo:

            
from flask import Flask, g, request, current_app
import sqlite3

app = Flask(__name__)
app.config['DATABASE_URI_GLOBAL'] = 'global_data.db'
app.config['DATABASE_URI_USERS'] = 'user_specific_data.db'

def get_db(db_uri):
    db = getattr(g, '_database', None)
    if db is None:
        db = g._database = sqlite3.connect(db_uri)
        # Opcional: Configurar cómo se devuelven las filas (por ejemplo, como diccionarios)
        db.row_factory = sqlite3.Row
    return db

@app.before_request
def setup_db_connection():
    # Determinar qué base de datos usar en función de la solicitud, por ejemplo, la región del usuario
    user_region = request.args.get('region', 'global') # 'global' o 'user'

    if user_region == 'user':
        # En una aplicación real, user_id vendría de la sesión/autenticación
        g.db_uri = current_app.config['DATABASE_URI_USERS']
    else:
        g.db_uri = current_app.config['DATABASE_URI_GLOBAL']

    g.db = get_db(g.db_uri)

@app.teardown_request
def close_db_connection(exception):
    db = getattr(g, '_database', None)
    if db is not None:
        db.close()

@app.route('/data')
def get_data():
    cursor = g.db.execute('SELECT * FROM items')
    items = cursor.fetchall()
    return f"Datos de {g.db_uri}: {items}"

# Uso de ejemplo: /data?region=global o /data?region=user

            

              
                Copy
              
            
          

Este patrón asegura que cada solicitud usa su propia conexión a la base de datos, que se abre y se cierra eficientemente para esa solicitud específica. El current_app.config proporciona acceso a diferentes configuraciones de base de datos, y g gestiona la conexión activa para la solicitud.

Mejores Prácticas para la Gestión de Contextos en Aplicaciones Globales

1. Favorecer `g` para Datos Específicos de la Solicitud:

Use el objeto g para almacenar datos que solo son relevantes para la duración de una sola solicitud (por ejemplo, conexiones a la base de datos, objetos de usuario autenticados, valores calculados únicos para la solicitud). Esto mantiene los datos de la solicitud aislados y evita que se filtren entre solicitudes.

2. Comprender la Pila:

Recuerde siempre que el contexto de solicitud se empuja encima del contexto de la aplicación. Esto significa que current_app está disponible cuando request lo está, pero no necesariamente al revés. Tenga esto en cuenta al escribir código que podría ejecutarse fuera de un ciclo de solicitud completo.

3. Empujar Explícitamente los Contextos Cuando Sea Necesario:

En pruebas unitarias, tareas en segundo plano o comandos CLI, no asuma que un contexto está activo. Use with app.app_context(): y with app.request_context(...): para gestionar manualmente los contextos y asegurarse de que los proxies como current_app y request funcionen correctamente.

4. Use los Ganchos `before_request` y `teardown_request`:

Estos decoradores de Flask son potentes para configurar y desmantelar recursos específicos de la solicitud gestionados dentro de los contextos de la aplicación y la solicitud. Por ejemplo, abrir y cerrar conexiones a la base de datos o inicializar clientes de servicios externos.

5. Evitar las Variables Globales para el Estado:

Si bien los contextos de Flask brindan acceso global a objetos específicos (como current_app), evite usar variables globales de Python o variables a nivel de módulo para almacenar el estado mutable que necesita ser específico de la solicitud o de la aplicación de una manera que omita el sistema de contexto. Los contextos están diseñados para gestionar este estado de forma segura y correcta, especialmente en entornos concurrentes.

6. Diseñar para Escalabilidad y Concurrencia:

Los contextos son esenciales para hacer que las aplicaciones Flask sean seguras para subprocesos y escalables. Cada subproceso normalmente obtiene su propio contexto de aplicación y solicitud. Al usar correctamente los contextos (especialmente g), se asegura de que los diferentes subprocesos que procesan diferentes solicitudes no interfieran entre sí con los datos.

7. Aprovechar las Extensiones sabiamente:

Muchas extensiones de Flask (como Flask-SQLAlchemy, Flask-Login, Flask-Babel) dependen en gran medida de los contextos de aplicación y solicitud. Comprenda cómo estas extensiones usan contextos para gestionar su propio estado y recursos. Este conocimiento hará que la depuración y la integración personalizada sean mucho más fáciles.

Contextos en Escenarios Avanzados

Concurrencia e Hilos:

Los servidores web a menudo gestionan múltiples solicitudes simultáneamente utilizando subprocesos o trabajadores asíncronos. Cada subproceso que procesa una solicitud obtiene automáticamente su propio contexto de aplicación y solicitud. Este aislamiento es fundamental. Si usara una variable global simple para, digamos, el ID del usuario actual, diferentes subprocesos podrían sobrescribir los valores de los demás, lo que llevaría a un comportamiento impredecible y vulnerabilidades de seguridad. El objeto g, vinculado al contexto de la solicitud, asegura que los datos de cada subproceso estén separados.

Pruebas:

Probar las aplicaciones Flask de forma eficaz depende en gran medida de la gestión del contexto. El método test_client() en Flask devuelve un cliente de prueba que simula solicitudes. Cuando usa este cliente, Flask empuja automáticamente los contextos de aplicación y solicitud necesarios, lo que permite que su código de prueba acceda a proxies como request, session y current_app como si estuviera ocurriendo una solicitud real.

            
from flask import Flask, session, current_app

app = Flask(__name__)
app.secret_key = 'testing_key'

@app.route('/login')
def login():
    session['user'] = 'test_user'
    return 'Logged in'

@app.route('/user')
def get_user():
    return session.get('user', 'No user')

# Prueba usando el cliente de prueba
client = app.test_client()

response = client.get('/login')
assert response.status_code == 200

# Los datos de la sesión ahora están configurados dentro del contexto del cliente de prueba
response = client.get('/user')
assert response.get_data(as_text=True) == 'test_user'

# current_app también está disponible
with app.test_client() as c:
    with c.application.app_context(): # Empujar explícitamente el contexto de la aplicación si es necesario
        print(current_app.name)

            

              
                Copy
              
            
          

Tareas en Segundo Plano (por ejemplo, Celery):

Cuando delega tareas a trabajadores en segundo plano (como los gestionados por Celery), estos trabajadores a menudo se ejecutan en procesos o subprocesos separados, fuera del ciclo de solicitud del servidor web principal. Si su tarea en segundo plano necesita acceder a la configuración de la aplicación o realizar operaciones que requieren un contexto de aplicación, debe empujar manualmente un contexto de aplicación antes de ejecutar la tarea.

            
from your_flask_app import create_app # Asumiendo que tienes un patrón de fábrica
from flask import current_app

@celery.task
def process_background_data(data):
    app = create_app() # Obtén tu instancia de la aplicación Flask
    with app.app_context():
        # Ahora puedes usar de forma segura current_app
        config_value = current_app.config['SOME_BACKGROUND_SETTING']
        # ... realizar operaciones usando config_value ...
        print(f"Procesando con configuración: {config_value}")
    return "Tarea completada"

            

              
                Copy
              
            
          

Si no empuja un contexto de aplicación en tales escenarios, se producirán errores al intentar acceder a current_app u otros objetos dependientes del contexto.

Conclusión

El Contexto de Aplicación y el Contexto de Solicitud de Flask son elementos fundamentales para construir cualquier aplicación Flask, y se vuelven aún más críticos al diseñar para una audiencia global. Al comprender cómo estos contextos gestionan los datos específicos de la aplicación y la solicitud, y al emplear las mejores prácticas para su uso, puede crear aplicaciones que sean:

• Robustas: Menos propensas a problemas de concurrencia y fugas de estado.
• Escalables: Capaces de gestionar eficientemente cargas de trabajo crecientes y usuarios concurrentes.
• Mantenibles: Más fáciles de razonar y depurar debido a la gestión organizada del estado.
• Conocedoras de la Internacionalización: Capaces de adaptarse a las preferencias del usuario en cuanto a idioma, zonas horarias, monedas y más.

Dominar la gestión del contexto de Flask no se trata solo de aprender una característica del framework; se trata de construir una base sólida para aplicaciones web modernas y complejas que sirven a usuarios en todo el mundo. Adopte estos conceptos, experimente con ellos en sus proyectos y estará en camino de desarrollar experiencias web sofisticadas y con mentalidad global.